
using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Text;
using ProjectCommon2.Interfaces;


namespace PolePosition.v3.EntityLibrary
{
	// No comments for the class here, all are in Entity.cs.cst
    [DataContract(Namespace = "http://Chfa.DataContracts/2007/10", Name = "VendorDistributionPole")]
	public sealed partial class VendorDistributionPoleEntity
		: Classes.Bases.Entity, ProjectCommon2.Interfaces.ICustomEntity	   
	{
		/// <summary>
		/// Determines if a default value (equivalent to the database's default value) is returned when the value of a <c>null</c> property is requested. 
		/// This makes sure that the stored checksum of a <c>VendorDistributionPoleEntity</c> with <c>null</c> properties matches the checksum calculated
		/// the next time it is loaded from the database.
		/// </summary>
		/// <remarks>
		/// <para>
		/// This variable exists to solve the checksum discrepancy that arises because the database replaces <c>null</c> values with its own default values
		/// (note that this is only relevant for those Entities for which verifying the checksum is important). An explanation follows.</para>
		///
		/// <para>A <c>VendorDistributionPoleEntity</c> can contain properties whose values are <c>null</c> (either because they have not been set, or because they were
		/// explicitly set that way). If a <c>VendorDistributionPoleEntity</c> is persisted to the database in that state, some of the <c>null</c> values will be replaced
		/// with default values by the database. However, before the Entity is persisted to the database, a checksum is calculated for its non-null values, and this
		/// checksum is stored in the database along with the rest of its values in order to validate it next time the Entity is loaded (see how the 
		/// <see cref="CheckSum" /> property works).
		/// </para>
		/// <para>Obviously, the original checksum calculated for an Entity with <c>null</c> properties will differ from the one calculated from its values
		/// the next time it is loaded from the database, since some of the null values were replaced by default values. Performing a checksum test on this Entity
		/// would raise a false <see cref="ProjectCommon2.Exceptions.EntityCheckSumSecurityException" />.
		/// </para>
		/// <para>To avoid this, <c>EnableDefaults</c> should be set to <c>true</c> for those Entities before persisting them to the database. If this is done,
		/// the Entity's column properties do not simply return <c>null</c> if its values are <c>null</c>. Instead, they return a value equivalent to the one the
		/// database would create for the <c>null</c> values (see the documentation for any of the column properties to see how they work). In this way, the
		/// Entity's original checksum, the one stored in the database, is created from the same values that will be used to calculate a checksum the next time 
		/// the Entity is loaded, thus eliminating the checksum discrepancy.
		/// </para>
		/// </remarks>
		public bool EnableDefaults;

		#region " Column Properties "
		
			
			
				
					// AcquisitionDate
					/// <summary>
					/// Stores the value of the AcquisitionDate column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>AcquisitionDate</c>),
					/// but through the <see cref="AcquisitionDateObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="AcquisitionDateObject" /> or the <see cref="AcquisitionDate" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<DateTime?> prop_AcquisitionDate;
					
					/// <summary>
					/// Gets the helper object that stores the value of the AcquisitionDate column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the AcquisitionDate column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_AcquisitionDate" /> member or the <see cref="AcquisitionDate" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_AcquisitionDate" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<DateTime?> AcquisitionDateObject
					{
						get
						{
							if (prop_AcquisitionDate == null)
							{
								prop_AcquisitionDate = new ProjectCommon2.Helpers.PropertyHelper<DateTime?>();
							}
							return prop_AcquisitionDate;
						}
						private set
						{
							prop_AcquisitionDate = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the AcquisitionDate
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_AcquisitionDate" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="AcquisitionDateObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_AcquisitionDate</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// AcquisitionDate corresponds to the database column "tb_Vendor_Distribution_Poles.AcquisitionDate". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 23.</item>
					/// <item>Scale: 3.</item>
					/// <item>System type: System.DateTime.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_AcquisitionDate' />.</value>
					[DataMember()]
					public DateTime? AcquisitionDate
					{
						get
						{
							if (EnableDefaults & AcquisitionDateObject.IsNull)
							{
								return null;
							}
							return AcquisitionDateObject.Value;
						}
						set
						{
							AcquisitionDateObject.Value = value;
						}
					}
				
					// ACSR
					/// <summary>
					/// Stores the value of the ACSR column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ACSR</c>),
					/// but through the <see cref="ACSRObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ACSRObject" /> or the <see cref="ACSR" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_ACSR;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ACSR column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ACSR column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ACSR" /> member or the <see cref="ACSR" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ACSR" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> ACSRObject
					{
						get
						{
							if (prop_ACSR == null)
							{
								prop_ACSR = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_ACSR;
						}
						private set
						{
							prop_ACSR = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ACSR
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ACSR" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ACSRObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ACSR</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ACSR corresponds to the database column "tb_Vendor_Distribution_Poles.ACSR". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ACSR' />.</value>
					[DataMember()]
					public int? ACSR
					{
						get
						{
							if (EnableDefaults & ACSRObject.IsNull)
							{
								return null;
							}
							return ACSRObject.Value;
						}
						set
						{
							ACSRObject.Value = value;
						}
					}
				
					// Billable
					/// <summary>
					/// Stores the value of the Billable column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Billable</c>),
					/// but through the <see cref="BillableObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="BillableObject" /> or the <see cref="Billable" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<bool?> prop_Billable;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Billable column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Billable column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Billable" /> member or the <see cref="Billable" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Billable" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<bool?> BillableObject
					{
						get
						{
							if (prop_Billable == null)
							{
								prop_Billable = new ProjectCommon2.Helpers.PropertyHelper<bool?>();
							}
							return prop_Billable;
						}
						private set
						{
							prop_Billable = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Billable
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Billable" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="BillableObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Billable</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Billable corresponds to the database column "tb_Vendor_Distribution_Poles.Billable". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 1.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 1.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Boolean.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Billable' />.</value>
					[DataMember()]
					public bool? Billable
					{
						get
						{
							if (EnableDefaults & BillableObject.IsNull)
							{
								return null;
							}
							return BillableObject.Value;
						}
						set
						{
							BillableObject.Value = value;
						}
					}
				
					// Circuit
					/// <summary>
					/// Stores the value of the Circuit column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Circuit</c>),
					/// but through the <see cref="CircuitObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="CircuitObject" /> or the <see cref="Circuit" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_Circuit;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Circuit column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Circuit column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Circuit" /> member or the <see cref="Circuit" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Circuit" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> CircuitObject
					{
						get
						{
							if (prop_Circuit == null)
							{
								prop_Circuit = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_Circuit;
						}
						private set
						{
							prop_Circuit = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Circuit
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Circuit" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="CircuitObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Circuit</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Circuit corresponds to the database column "tb_Vendor_Distribution_Poles.Circuit". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Circuit' />.</value>
					[DataMember()]
					public string Circuit
					{
						get
						{
							if (EnableDefaults & CircuitObject.IsNull)
							{
								return null;
							}
							return CircuitObject.Value;
						}
						set
						{
							CircuitObject.Value = value;
						}
					}
				
					// ClassFK
					/// <summary>
					/// Stores the value of the ClassFK column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ClassFK</c>),
					/// but through the <see cref="ClassFKObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ClassFKObject" /> or the <see cref="ClassFK" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_ClassFK;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ClassFK column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ClassFK column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ClassFK" /> member or the <see cref="ClassFK" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ClassFK" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> ClassFKObject
					{
						get
						{
							if (prop_ClassFK == null)
							{
								prop_ClassFK = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_ClassFK;
						}
						private set
						{
							prop_ClassFK = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ClassFK
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ClassFK" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ClassFKObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ClassFK</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ClassFK corresponds to the database column "tb_Vendor_Distribution_Poles.ClassFK". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ClassFK' />.</value>
					[DataMember()]
					public int? ClassFK
					{
						get
						{
							if (EnableDefaults & ClassFKObject.IsNull)
							{
								return null;
							}
							return ClassFKObject.Value;
						}
						set
						{
							ClassFKObject.Value = value;
						}
					}
				
					// ConductorType
					/// <summary>
					/// Stores the value of the ConductorType column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ConductorType</c>),
					/// but through the <see cref="ConductorTypeObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ConductorTypeObject" /> or the <see cref="ConductorType" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_ConductorType;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ConductorType column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ConductorType column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ConductorType" /> member or the <see cref="ConductorType" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ConductorType" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> ConductorTypeObject
					{
						get
						{
							if (prop_ConductorType == null)
							{
								prop_ConductorType = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_ConductorType;
						}
						private set
						{
							prop_ConductorType = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ConductorType
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ConductorType" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ConductorTypeObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ConductorType</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ConductorType corresponds to the database column "tb_Vendor_Distribution_Poles.ConductorType". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ConductorType' />.</value>
					[DataMember()]
					public int? ConductorType
					{
						get
						{
							if (EnableDefaults & ConductorTypeObject.IsNull)
							{
								return null;
							}
							return ConductorTypeObject.Value;
						}
						set
						{
							ConductorTypeObject.Value = value;
						}
					}
				
					// D804
					/// <summary>
					/// Stores the value of the D804 column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>D804</c>),
					/// but through the <see cref="D804Object" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="D804Object" /> or the <see cref="D804" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_D804;
					
					/// <summary>
					/// Gets the helper object that stores the value of the D804 column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the D804 column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_D804" /> member or the <see cref="D804" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_D804" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> D804Object
					{
						get
						{
							if (prop_D804 == null)
							{
								prop_D804 = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_D804;
						}
						private set
						{
							prop_D804 = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the D804
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_D804" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="D804Object" />, which is a read-only property that returns a reference to the 
					/// <c>prop_D804</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// D804 corresponds to the database column "tb_Vendor_Distribution_Poles.D804". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 50.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_D804' />.</value>
					[DataMember()]
					public string D804
					{
						get
						{
							if (EnableDefaults & D804Object.IsNull)
							{
								return null;
							}
							return D804Object.Value;
						}
						set
						{
							D804Object.Value = value;
						}
					}
				
					// DistributionType
					/// <summary>
					/// Stores the value of the DistributionType column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>DistributionType</c>),
					/// but through the <see cref="DistributionTypeObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="DistributionTypeObject" /> or the <see cref="DistributionType" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_DistributionType;
					
					/// <summary>
					/// Gets the helper object that stores the value of the DistributionType column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the DistributionType column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_DistributionType" /> member or the <see cref="DistributionType" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_DistributionType" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> DistributionTypeObject
					{
						get
						{
							if (prop_DistributionType == null)
							{
								prop_DistributionType = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_DistributionType;
						}
						private set
						{
							prop_DistributionType = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the DistributionType
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_DistributionType" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="DistributionTypeObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_DistributionType</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// DistributionType corresponds to the database column "tb_Vendor_Distribution_Poles.DistributionType". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_DistributionType' />.</value>
					[DataMember()]
					public int? DistributionType
					{
						get
						{
							if (EnableDefaults & DistributionTypeObject.IsNull)
							{
								return null;
							}
							return DistributionTypeObject.Value;
						}
						set
						{
							DistributionTypeObject.Value = value;
						}
					}
				
					// GroundWireRepair
					/// <summary>
					/// Stores the value of the GroundWireRepair column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>GroundWireRepair</c>),
					/// but through the <see cref="GroundWireRepairObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="GroundWireRepairObject" /> or the <see cref="GroundWireRepair" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<bool?> prop_GroundWireRepair;
					
					/// <summary>
					/// Gets the helper object that stores the value of the GroundWireRepair column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the GroundWireRepair column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_GroundWireRepair" /> member or the <see cref="GroundWireRepair" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_GroundWireRepair" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<bool?> GroundWireRepairObject
					{
						get
						{
							if (prop_GroundWireRepair == null)
							{
								prop_GroundWireRepair = new ProjectCommon2.Helpers.PropertyHelper<bool?>();
							}
							return prop_GroundWireRepair;
						}
						private set
						{
							prop_GroundWireRepair = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the GroundWireRepair
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_GroundWireRepair" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="GroundWireRepairObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_GroundWireRepair</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// GroundWireRepair corresponds to the database column "tb_Vendor_Distribution_Poles.GroundWireRepair". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 1.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 1.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Boolean.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_GroundWireRepair' />.</value>
					[DataMember()]
					public bool? GroundWireRepair
					{
						get
						{
							if (EnableDefaults & GroundWireRepairObject.IsNull)
							{
								return null;
							}
							return GroundWireRepairObject.Value;
						}
						set
						{
							GroundWireRepairObject.Value = value;
						}
					}
				
					// GuardsQuantity
					/// <summary>
					/// Stores the value of the GuardsQuantity column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>GuardsQuantity</c>),
					/// but through the <see cref="GuardsQuantityObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="GuardsQuantityObject" /> or the <see cref="GuardsQuantity" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_GuardsQuantity;
					
					/// <summary>
					/// Gets the helper object that stores the value of the GuardsQuantity column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the GuardsQuantity column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_GuardsQuantity" /> member or the <see cref="GuardsQuantity" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_GuardsQuantity" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> GuardsQuantityObject
					{
						get
						{
							if (prop_GuardsQuantity == null)
							{
								prop_GuardsQuantity = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_GuardsQuantity;
						}
						private set
						{
							prop_GuardsQuantity = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the GuardsQuantity
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_GuardsQuantity" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="GuardsQuantityObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_GuardsQuantity</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// GuardsQuantity corresponds to the database column "tb_Vendor_Distribution_Poles.GuardsQuantity". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_GuardsQuantity' />.</value>
					[DataMember()]
					public int? GuardsQuantity
					{
						get
						{
							if (EnableDefaults & GuardsQuantityObject.IsNull)
							{
								return null;
							}
							return GuardsQuantityObject.Value;
						}
						set
						{
							GuardsQuantityObject.Value = value;
						}
					}
				
					// InspBy
					/// <summary>
					/// Stores the value of the InspBy column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>InspBy</c>),
					/// but through the <see cref="InspByObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="InspByObject" /> or the <see cref="InspBy" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_InspBy;
					
					/// <summary>
					/// Gets the helper object that stores the value of the InspBy column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the InspBy column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_InspBy" /> member or the <see cref="InspBy" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_InspBy" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> InspByObject
					{
						get
						{
							if (prop_InspBy == null)
							{
								prop_InspBy = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_InspBy;
						}
						private set
						{
							prop_InspBy = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the InspBy
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_InspBy" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="InspByObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_InspBy</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// InspBy corresponds to the database column "tb_Vendor_Distribution_Poles.InspBy". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_InspBy' />.</value>
					[DataMember()]
					public string InspBy
					{
						get
						{
							if (EnableDefaults & InspByObject.IsNull)
							{
								return null;
							}
							return InspByObject.Value;
						}
						set
						{
							InspByObject.Value = value;
						}
					}
				
					// InspectorFk
					/// <summary>
					/// Stores the value of the InspectorFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>InspectorFk</c>),
					/// but through the <see cref="InspectorFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="InspectorFkObject" /> or the <see cref="InspectorFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_InspectorFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the InspectorFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the InspectorFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_InspectorFk" /> member or the <see cref="InspectorFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_InspectorFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> InspectorFkObject
					{
						get
						{
							if (prop_InspectorFk == null)
							{
								prop_InspectorFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_InspectorFk;
						}
						private set
						{
							prop_InspectorFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the InspectorFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_InspectorFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="InspectorFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_InspectorFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// InspectorFk corresponds to the database column "tb_Vendor_Distribution_Poles.InspectorFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_InspectorFk' />.</value>
					[DataMember()]
					public int? InspectorFk
					{
						get
						{
							if (EnableDefaults & InspectorFkObject.IsNull)
							{
								return null;
							}
							return InspectorFkObject.Value;
						}
						set
						{
							InspectorFkObject.Value = value;
						}
					}
				
					// Kv
					/// <summary>
					/// Stores the value of the Kv column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Kv</c>),
					/// but through the <see cref="KvObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="KvObject" /> or the <see cref="Kv" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Kv;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Kv column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Kv column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Kv" /> member or the <see cref="Kv" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Kv" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> KvObject
					{
						get
						{
							if (prop_Kv == null)
							{
								prop_Kv = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Kv;
						}
						private set
						{
							prop_Kv = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Kv
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Kv" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="KvObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Kv</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Kv corresponds to the database column "tb_Vendor_Distribution_Poles.Kv". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Kv' />.</value>
					[DataMember()]
					public int? Kv
					{
						get
						{
							if (EnableDefaults & KvObject.IsNull)
							{
								return null;
							}
							return KvObject.Value;
						}
						set
						{
							KvObject.Value = value;
						}
					}
				
					// Latitude
					/// <summary>
					/// Stores the value of the Latitude column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Latitude</c>),
					/// but through the <see cref="LatitudeObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="LatitudeObject" /> or the <see cref="Latitude" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<decimal?> prop_Latitude;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Latitude column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Latitude column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Latitude" /> member or the <see cref="Latitude" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Latitude" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<decimal?> LatitudeObject
					{
						get
						{
							if (prop_Latitude == null)
							{
								prop_Latitude = new ProjectCommon2.Helpers.PropertyHelper<decimal?>();
							}
							return prop_Latitude;
						}
						private set
						{
							prop_Latitude = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Latitude
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Latitude" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="LatitudeObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Latitude</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Latitude corresponds to the database column "tb_Vendor_Distribution_Poles.Latitude". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 53.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Double.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Latitude' />.</value>
					[DataMember()]
					public decimal? Latitude
					{
						get
						{
							if (EnableDefaults & LatitudeObject.IsNull)
							{
								return null;
							}
							return LatitudeObject.Value;
						}
						set
						{
							LatitudeObject.Value = value;
						}
					}
				
					// LengthFk
					/// <summary>
					/// Stores the value of the LengthFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>LengthFk</c>),
					/// but through the <see cref="LengthFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="LengthFkObject" /> or the <see cref="LengthFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_LengthFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the LengthFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the LengthFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_LengthFk" /> member or the <see cref="LengthFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_LengthFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> LengthFkObject
					{
						get
						{
							if (prop_LengthFk == null)
							{
								prop_LengthFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_LengthFk;
						}
						private set
						{
							prop_LengthFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the LengthFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_LengthFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="LengthFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_LengthFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// LengthFk corresponds to the database column "tb_Vendor_Distribution_Poles.LengthFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_LengthFk' />.</value>
					[DataMember()]
					public int? LengthFk
					{
						get
						{
							if (EnableDefaults & LengthFkObject.IsNull)
							{
								return null;
							}
							return LengthFkObject.Value;
						}
						set
						{
							LengthFkObject.Value = value;
						}
					}
				
					// Longitude
					/// <summary>
					/// Stores the value of the Longitude column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Longitude</c>),
					/// but through the <see cref="LongitudeObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="LongitudeObject" /> or the <see cref="Longitude" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<decimal?> prop_Longitude;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Longitude column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Longitude column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Longitude" /> member or the <see cref="Longitude" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Longitude" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<decimal?> LongitudeObject
					{
						get
						{
							if (prop_Longitude == null)
							{
								prop_Longitude = new ProjectCommon2.Helpers.PropertyHelper<decimal?>();
							}
							return prop_Longitude;
						}
						private set
						{
							prop_Longitude = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Longitude
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Longitude" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="LongitudeObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Longitude</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Longitude corresponds to the database column "tb_Vendor_Distribution_Poles.Longitude". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 53.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Double.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Longitude' />.</value>
					[DataMember()]
					public decimal? Longitude
					{
						get
						{
							if (EnableDefaults & LongitudeObject.IsNull)
							{
								return null;
							}
							return LongitudeObject.Value;
						}
						set
						{
							LongitudeObject.Value = value;
						}
					}
				
					// LVisit
					/// <summary>
					/// Stores the value of the LVisit column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>LVisit</c>),
					/// but through the <see cref="LVisitObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="LVisitObject" /> or the <see cref="LVisit" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<DateTime?> prop_LVisit;
					
					/// <summary>
					/// Gets the helper object that stores the value of the LVisit column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the LVisit column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_LVisit" /> member or the <see cref="LVisit" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_LVisit" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<DateTime?> LVisitObject
					{
						get
						{
							if (prop_LVisit == null)
							{
								prop_LVisit = new ProjectCommon2.Helpers.PropertyHelper<DateTime?>();
							}
							return prop_LVisit;
						}
						private set
						{
							prop_LVisit = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the LVisit
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_LVisit" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="LVisitObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_LVisit</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// LVisit corresponds to the database column "tb_Vendor_Distribution_Poles.LVisit". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 23.</item>
					/// <item>Scale: 3.</item>
					/// <item>System type: System.DateTime.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_LVisit' />.</value>
					[DataMember()]
					public DateTime? LVisit
					{
						get
						{
							if (EnableDefaults & LVisitObject.IsNull)
							{
								return null;
							}
							return LVisitObject.Value;
						}
						set
						{
							LVisitObject.Value = value;
						}
					}
				
					// MapFk
					/// <summary>
					/// Stores the value of the MapFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>MapFk</c>),
					/// but through the <see cref="MapFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="MapFkObject" /> or the <see cref="MapFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_MapFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the MapFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the MapFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_MapFk" /> member or the <see cref="MapFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_MapFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> MapFkObject
					{
						get
						{
							if (prop_MapFk == null)
							{
								prop_MapFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_MapFk;
						}
						private set
						{
							prop_MapFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the MapFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_MapFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="MapFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_MapFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// MapFk corresponds to the database column "tb_Vendor_Distribution_Poles.MapFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_MapFk' />.</value>
					[DataMember()]
					public int? MapFk
					{
						get
						{
							if (EnableDefaults & MapFkObject.IsNull)
							{
								return null;
							}
							return MapFkObject.Value;
						}
						set
						{
							MapFkObject.Value = value;
						}
					}
				
					// Number
					/// <summary>
					/// Stores the value of the Number column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Number</c>),
					/// but through the <see cref="NumberObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="NumberObject" /> or the <see cref="Number" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_Number;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Number column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Number column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Number" /> member or the <see cref="Number" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Number" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> NumberObject
					{
						get
						{
							if (prop_Number == null)
							{
								prop_Number = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_Number;
						}
						private set
						{
							prop_Number = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Number
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Number" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="NumberObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Number</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Number corresponds to the database column "tb_Vendor_Distribution_Poles.Number". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Number' />.</value>
					[DataMember()]
					public string Number
					{
						get
						{
							if (EnableDefaults & NumberObject.IsNull)
							{
								return null;
							}
							return NumberObject.Value;
						}
						set
						{
							NumberObject.Value = value;
						}
					}
				
					// PoleTag
					/// <summary>
					/// Stores the value of the PoleTag column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>PoleTag</c>),
					/// but through the <see cref="PoleTagObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="PoleTagObject" /> or the <see cref="PoleTag" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<bool?> prop_PoleTag;
					
					/// <summary>
					/// Gets the helper object that stores the value of the PoleTag column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the PoleTag column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_PoleTag" /> member or the <see cref="PoleTag" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_PoleTag" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<bool?> PoleTagObject
					{
						get
						{
							if (prop_PoleTag == null)
							{
								prop_PoleTag = new ProjectCommon2.Helpers.PropertyHelper<bool?>();
							}
							return prop_PoleTag;
						}
						private set
						{
							prop_PoleTag = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the PoleTag
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_PoleTag" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="PoleTagObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_PoleTag</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// PoleTag corresponds to the database column "tb_Vendor_Distribution_Poles.PoleTag". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 1.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 1.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Boolean.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_PoleTag' />.</value>
					[DataMember()]
					public bool? PoleTag
					{
						get
						{
							if (EnableDefaults & PoleTagObject.IsNull)
							{
								return null;
							}
							return PoleTagObject.Value;
						}
						set
						{
							PoleTagObject.Value = value;
						}
					}
				
					// ProjectFk
					/// <summary>
					/// Stores the value of the ProjectFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ProjectFk</c>),
					/// but through the <see cref="ProjectFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ProjectFkObject" /> or the <see cref="ProjectFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_ProjectFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ProjectFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ProjectFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ProjectFk" /> member or the <see cref="ProjectFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ProjectFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> ProjectFkObject
					{
						get
						{
							if (prop_ProjectFk == null)
							{
								prop_ProjectFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_ProjectFk;
						}
						private set
						{
							prop_ProjectFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ProjectFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ProjectFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ProjectFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ProjectFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ProjectFk corresponds to the database column "tb_Vendor_Distribution_Poles.ProjectFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ProjectFk' />.</value>
					[DataMember()]
					public int? ProjectFk
					{
						get
						{
							if (EnableDefaults & ProjectFkObject.IsNull)
							{
								return null;
							}
							return ProjectFkObject.Value;
						}
						set
						{
							ProjectFkObject.Value = value;
						}
					}
				
					// SectionFk
					/// <summary>
					/// Stores the value of the SectionFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>SectionFk</c>),
					/// but through the <see cref="SectionFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="SectionFkObject" /> or the <see cref="SectionFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_SectionFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the SectionFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the SectionFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_SectionFk" /> member or the <see cref="SectionFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_SectionFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> SectionFkObject
					{
						get
						{
							if (prop_SectionFk == null)
							{
								prop_SectionFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_SectionFk;
						}
						private set
						{
							prop_SectionFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the SectionFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_SectionFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="SectionFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_SectionFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// SectionFk corresponds to the database column "tb_Vendor_Distribution_Poles.SectionFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_SectionFk' />.</value>
					[DataMember()]
					public int? SectionFk
					{
						get
						{
							if (EnableDefaults & SectionFkObject.IsNull)
							{
								return null;
							}
							return SectionFkObject.Value;
						}
						set
						{
							SectionFkObject.Value = value;
						}
					}
				
					// SpecieFk
					/// <summary>
					/// Stores the value of the SpecieFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>SpecieFk</c>),
					/// but through the <see cref="SpecieFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="SpecieFkObject" /> or the <see cref="SpecieFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_SpecieFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the SpecieFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the SpecieFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_SpecieFk" /> member or the <see cref="SpecieFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_SpecieFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> SpecieFkObject
					{
						get
						{
							if (prop_SpecieFk == null)
							{
								prop_SpecieFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_SpecieFk;
						}
						private set
						{
							prop_SpecieFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the SpecieFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_SpecieFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="SpecieFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_SpecieFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// SpecieFk corresponds to the database column "tb_Vendor_Distribution_Poles.SpecieFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_SpecieFk' />.</value>
					[DataMember()]
					public int? SpecieFk
					{
						get
						{
							if (EnableDefaults & SpecieFkObject.IsNull)
							{
								return null;
							}
							return SpecieFkObject.Value;
						}
						set
						{
							SpecieFkObject.Value = value;
						}
					}
				
					// TreatmentFk
					/// <summary>
					/// Stores the value of the TreatmentFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>TreatmentFk</c>),
					/// but through the <see cref="TreatmentFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="TreatmentFkObject" /> or the <see cref="TreatmentFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_TreatmentFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the TreatmentFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the TreatmentFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_TreatmentFk" /> member or the <see cref="TreatmentFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_TreatmentFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> TreatmentFkObject
					{
						get
						{
							if (prop_TreatmentFk == null)
							{
								prop_TreatmentFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_TreatmentFk;
						}
						private set
						{
							prop_TreatmentFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the TreatmentFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_TreatmentFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="TreatmentFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_TreatmentFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// TreatmentFk corresponds to the database column "tb_Vendor_Distribution_Poles.TreatmentFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_TreatmentFk' />.</value>
					[DataMember()]
					public int? TreatmentFk
					{
						get
						{
							if (EnableDefaults & TreatmentFkObject.IsNull)
							{
								return null;
							}
							return TreatmentFkObject.Value;
						}
						set
						{
							TreatmentFkObject.Value = value;
						}
					}
				
					// UserFk
					/// <summary>
					/// Stores the value of the UserFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>UserFk</c>),
					/// but through the <see cref="UserFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="UserFkObject" /> or the <see cref="UserFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_UserFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the UserFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the UserFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_UserFk" /> member or the <see cref="UserFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_UserFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> UserFkObject
					{
						get
						{
							if (prop_UserFk == null)
							{
								prop_UserFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_UserFk;
						}
						private set
						{
							prop_UserFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the UserFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_UserFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="UserFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_UserFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// UserFk corresponds to the database column "tb_Vendor_Distribution_Poles.UserFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_UserFk' />.</value>
					[DataMember()]
					public int? UserFk
					{
						get
						{
							if (EnableDefaults & UserFkObject.IsNull)
							{
								return null;
							}
							return UserFkObject.Value;
						}
						set
						{
							UserFkObject.Value = value;
						}
					}
				
					// Utility_Asset_Distributions_PoleFk
					/// <summary>
					/// Stores the value of the Utility_Asset_Distributions_PoleFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Utility_Asset_Distributions_PoleFk</c>),
					/// but through the <see cref="Utility_Asset_Distributions_PoleFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="Utility_Asset_Distributions_PoleFkObject" /> or the <see cref="Utility_Asset_Distributions_PoleFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Utility_Asset_Distributions_PoleFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Utility_Asset_Distributions_PoleFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Utility_Asset_Distributions_PoleFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Utility_Asset_Distributions_PoleFk" /> member or the <see cref="Utility_Asset_Distributions_PoleFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Utility_Asset_Distributions_PoleFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> Utility_Asset_Distributions_PoleFkObject
					{
						get
						{
							if (prop_Utility_Asset_Distributions_PoleFk == null)
							{
								prop_Utility_Asset_Distributions_PoleFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Utility_Asset_Distributions_PoleFk;
						}
						private set
						{
							prop_Utility_Asset_Distributions_PoleFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Utility_Asset_Distributions_PoleFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Utility_Asset_Distributions_PoleFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="Utility_Asset_Distributions_PoleFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Utility_Asset_Distributions_PoleFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Utility_Asset_Distributions_PoleFk corresponds to the database column "tb_Vendor_Distribution_Poles.Utility_Asset_Distributions_PoleFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Utility_Asset_Distributions_PoleFk' />.</value>
					[DataMember()]
					public int? Utility_Asset_Distributions_PoleFk
					{
						get
						{
							if (EnableDefaults & Utility_Asset_Distributions_PoleFkObject.IsNull)
							{
								return null;
							}
							return Utility_Asset_Distributions_PoleFkObject.Value;
						}
						set
						{
							Utility_Asset_Distributions_PoleFkObject.Value = value;
						}
					}
				
					// Vendor_Distribution_Poles_PoleId
					/// <summary>
					/// Stores the value of the Vendor_Distribution_Poles_PoleId column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Vendor_Distribution_Poles_PoleId</c>),
					/// but through the <see cref="Vendor_Distribution_Poles_PoleIdObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="Vendor_Distribution_Poles_PoleIdObject" /> or the <see cref="Vendor_Distribution_Poles_PoleId" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Vendor_Distribution_Poles_PoleId;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Vendor_Distribution_Poles_PoleId column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Vendor_Distribution_Poles_PoleId column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Vendor_Distribution_Poles_PoleId" /> member or the <see cref="Vendor_Distribution_Poles_PoleId" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Vendor_Distribution_Poles_PoleId" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> Vendor_Distribution_Poles_PoleIdObject
					{
						get
						{
							if (prop_Vendor_Distribution_Poles_PoleId == null)
							{
								prop_Vendor_Distribution_Poles_PoleId = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Vendor_Distribution_Poles_PoleId;
						}
						private set
						{
							prop_Vendor_Distribution_Poles_PoleId = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Vendor_Distribution_Poles_PoleId
					/// column, which is (part of) the Primary Key of the VendorDistributionPole table.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Vendor_Distribution_Poles_PoleId" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="Vendor_Distribution_Poles_PoleIdObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Vendor_Distribution_Poles_PoleId</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Vendor_Distribution_Poles_PoleId corresponds to the database column "tb_Vendor_Distribution_Poles.Vendor_Distribution_Poles_PoleId". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  Yes. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  Yes  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  Yes. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Vendor_Distribution_Poles_PoleId' />.</value>
					[DataMember()]
					public int? Vendor_Distribution_Poles_PoleId
					{
						get
						{
							if (EnableDefaults & Vendor_Distribution_Poles_PoleIdObject.IsNull)
							{
								return null;
							}
							return Vendor_Distribution_Poles_PoleIdObject.Value;
						}
						set
						{
							Vendor_Distribution_Poles_PoleIdObject.Value = value;
						}
					}
				
					// VendorFk
					/// <summary>
					/// Stores the value of the VendorFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>VendorFk</c>),
					/// but through the <see cref="VendorFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="VendorFkObject" /> or the <see cref="VendorFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_VendorFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the VendorFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the VendorFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_VendorFk" /> member or the <see cref="VendorFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_VendorFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> VendorFkObject
					{
						get
						{
							if (prop_VendorFk == null)
							{
								prop_VendorFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_VendorFk;
						}
						private set
						{
							prop_VendorFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the VendorFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_VendorFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="VendorFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_VendorFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// VendorFk corresponds to the database column "tb_Vendor_Distribution_Poles.VendorFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_VendorFk' />.</value>
					[DataMember()]
					public int? VendorFk
					{
						get
						{
							if (EnableDefaults & VendorFkObject.IsNull)
							{
								return null;
							}
							return VendorFkObject.Value;
						}
						set
						{
							VendorFkObject.Value = value;
						}
					}
				
					// Year
					/// <summary>
					/// Stores the value of the Year column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Year</c>),
					/// but through the <see cref="YearObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="YearObject" /> or the <see cref="Year" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Year;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Year column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Year column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Year" /> member or the <see cref="Year" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Year" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> YearObject
					{
						get
						{
							if (prop_Year == null)
							{
								prop_Year = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Year;
						}
						private set
						{
							prop_Year = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Year
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Year" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="YearObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Year</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Year corresponds to the database column "tb_Vendor_Distribution_Poles.Year". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Year' />.</value>
					[DataMember()]
					public int? Year
					{
						get
						{
							if (EnableDefaults & YearObject.IsNull)
							{
								return null;
							}
							return YearObject.Value;
						}
						set
						{
							YearObject.Value = value;
						}
					}

			// Special: FriendlyName
			/// <summary>
			///	Stores the value of the FriendlyName column.
			/// </summary>
			/// <value>Human-readable form of <c>VendorDistributionPoleEntity</c>'s name.</value>
			private string prop_FriendlyName;

			/// <summary>
			/// Gets or Sets a value that contains a more descriptive, human-readable form of <c>VendorDistributionPoleEntity</c>'s name.
			/// </summary>
			/// <value>Human-readable form of <c>VendorDistributionPoleEntity</c>'s name.</value>
			/// <remarks>Although <c>Set</c> is available, this value is never written back to the database. It is 
			/// made up from other columns in the database by the stored procedure that retrieves <c>VendorDistributionPoleEntity</c>'s
			/// record from the database.</remarks>
			[DataMember()]
			public string FriendlyName
			{
				get
				{
					return prop_FriendlyName;
				}
				set
				{
					prop_FriendlyName = value;
				}
			}
			
		#endregion

		#region " Other Properties "
		
		/// <summary>
		/// Stores a manually set value that indicates if <c>VendorDistributionPoleEntity</c>'s data is new.
		/// </summary>
		/// <remarks>
		/// Normally, this field should stay <c>null</c> to let <see cref="IsNew" />'s logic
		/// decide whether to return <c>true</c> or <c>false</c>.
		/// </remarks>
		private bool? prop_IsNew;
		
		/// <summary>
		/// Gets or Sets a value that specifies whether <c>VendorDistributionPoleEntity</c> contains new VendorDistributionPole data
		/// or data loaded from an existing VendorDistributionPole record.
		/// <para> </para>
		/// <c>True</c> if the data is new; <c>false</c> if it is from an existing record.
		/// </summary>
		/// <remarks>
		/// <para>Provided that its associated field (<see cref="prop_IsNew" />) stays <c>null</c>, this property returns
		/// <c>true</c> if no Primary Key value exists for <c>VendorDistributionPoleEntity</c>; false if there is one. This determines
		/// if a persist command (calling VendorDistributionPoleFactory's <c>Save()</c> method) will cause an <c>INSERT</c> or an
		/// <c>UPDATE</c> in the database. For more information, see how
		/// <see cref="Classes.Factories.VendorDistributionPoleFactory.Save(Classes.Entities.VendorDistributionPoleEntity, bool)" /> works.
		/// </para>
		/// <para>Note that manually setting this property's value to something other than <c>null</c> will bypass its logic,
		/// and it will return whatever value it is set to, even if it is incorrect.</para>
		/// </remarks>
		/// <value>Indicates if <c>VendorDistributionPoleEntity</c>'s data is new. Can be set to <c>true</c> (to indicate new data), <c>false</c>, 
		/// or <c>null</c>.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool? IsNew
		{
			get
			{
				// support manually overriding the IsNew value
				if (prop_IsNew != null)
				{
                    return prop_IsNew;
				}
                // Check IsDirty of key only
                return (this.Vendor_Distribution_Poles_PoleIdObject.IsNull);
			}
			set
			{
				// manually override IsNew
				prop_IsNew = value;
			}
		}
		
		/// <summary>
		/// Stores a value that indicates whether <c>VendorDistributionPoleEntity</c> has been modified.
		/// </summary>
		/// <remarks>
		/// Normally, this field should stay <c>null</c> to let <see cref="IsDirty" />'s logic
		/// decide whether to return <c>true</c> or <c>false</c>.
		/// </remarks>
		private bool? prop_IsDirty;
		
		/// <summary>
		/// Gets a value that specifies whether <c>VendorDistributionPoleEntity</c>'s data has been modified since it was first loaded, or
		/// since the last time its <c>AcceptChanges()</c> method was called.
		/// <para> </para>
		/// <c>True</c> if the Entity has changed; <c>false</c> if it has not.
		/// </summary>
		/// <remarks>
		/// <para>Provided that its associated field (<see cref="prop_IsDirty" />) stays <c>null</c>, it returns <c>true</c> if
		/// the Entity's <see cref="IsNew" /> or <see cref="IsMarkedToDelete" /> properties are <c>true</c>. If none of them is, 
		/// it will check whether its <see cref="CheckSum" /> has changed and return an appropiate value based on the result of 
		/// that check.</para>
		/// <para>The value returned by <c>IsDirty</c> determines if a persist command (calling VendorDistributionPoleFactory's <c>Save()</c>)
		/// will <c>UPDATE</c> the corresponding record in the database. For more information, see how
		/// <see cref="Classes.Factories.VendorDistributionPoleFactory.Save(Classes.Entities.VendorDistributionPoleEntity, bool)" /> works.
		/// </para>
		/// <para>Note that manually setting this property's value to something other than <c>null</c> will bypass its logic,
		/// and it will return whatever value it is set to, even if it is incorrect.</para>
		/// </remarks>
		/// <value><c>Indicates if VendorDistributionPoleEntity</c> has been modified. <c>True</c> if it has; <c>false</c> otherwise.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool? IsDirty
		{
			get
			{
				
				// support manually overriding the IsDirty value
				if (prop_IsDirty != null)
				{
                    return prop_IsDirty;
				}

				if (IsNew == true)
					return true;
					
				if (IsMarkedToDelete == true)
					return true;
				
				if (CheckSumOriginal != CheckSum)
					return true;
					
				return RecurseBooleanProperty(this, "IsDirty");
			}
			private set
			{
				//only set the variable if manually set. Set is only available for serialization and should
				//only be used for reconstruction by deserialization.
				if (m_IsDirtyManuallySet)
					prop_IsDirty = value;
			}
		}
		
		//private variable supplied for deserialization, so that if the IsDirty was set manually the
		//prop_IsDirty can be set on reconstruction
		private bool m_IsDirtyManuallySet;
		
		/// <summary>
		/// Sets a value that indicates whether <c>VendorDistributionPoleEntity</c> has changed.
		/// <para> </para>
		/// Use <c>true</c> if the Entity has changed, <c>false</c> if not, or <c>null</c> to let
		/// the <see cref="IsDirty" /> property determine an appropiate value.
		/// </summary>
		/// <remarks>If set to something other than <c>null</c>, this overrides the <see cref="IsDirty" /> property's logic so that it will return the assigned
		/// value even if it is incorrect.</remarks>
		/// <value><c>Indicates if VendorDistributionPoleEntity</c> has been modified. <c>True</c> if it has; <c>false</c> otherwise.</value>
		public void SetManualIsDirty(bool? value)
		{
			// manually override IsDirty
			prop_IsDirty = value;
			
			if (value == null)
				m_IsDirtyManuallySet = false;
			else
				m_IsDirtyManuallySet = true;
			
		}

		/// <summary>
		/// Stores a value that indicates whether the <c>VendorDistributionPoleEntity</c> is to be deleted.
		/// </summary>
		private bool prop_IsMarkedToDelete;
		
		/// <summary>
		/// Gets or Sets a value that specifies whether <c>VendorDistributionPoleEntity</c>'s data is to be removed from the database.
		/// <para> </para>
		/// <c>True</c> deletes the VendorDistributionPole data.
		/// </summary>
		/// <remarks>Determines if a persist command (calling VendorDistributionPoleFactory's <c>Save()</c>) will DELETE the Entity's
		/// corresponding record in the database. For more information, see how
		/// <see cref="Classes.Factories.VendorDistributionPoleFactory.Save(Classes.Entities.VendorDistributionPoleEntity, bool)" /> works.
		/// </remarks>
		/// <value><c>VendorDistributionPoleEntity</c>'s deletion mark. <c>True</c> to delete; <c>false</c> otherwise.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool IsMarkedToDelete
		{
			get
			{
				return prop_IsMarkedToDelete;
			}
			set
			{
				prop_IsMarkedToDelete = value;
			}
		}

		/// <summary>
		/// Gets a unique checksum for <c>VendorDistributionPoleEntity</c>, calculated from its current property values.
		/// </summary>
		/// <remarks>
		/// <para>This property creates a checksum for <c>VendorDistributionPoleEntity</c>'s values by calling
		/// <see cref="PolePosition.v3.EntityLibrary.Entity.MakeHash" />, and sending it every column property's values, except for Checksum,
		/// the Primary Key, and any <c>null</c> properties.
		///</para>
		/// <para>The checksum is stored in the database along with the rest of <c>VendorDistributionPoleEntity</c>'s values when it is
		/// created or modified. Then, whenever <c>VendorDistributionPoleEntity</c> is loaded from the database, a new checksum is calculated
		/// on the loaded values and compared to the stored checksum (see <see cref="LoadFromDataRow(System.Data.DataRow, bool)" />).
		/// Because the checksum is unique for a specified set of values, if the database values were modified by someone without proper
		/// authorization, the checksums will not match, and an <see cref="ProjectCommon2.Exceptions.EntityCheckSumSecurityException" />
		/// will be thrown.
		/// </para>
		/// </remarks>
		/// <value>String that uniquely identifies the contents of the Entity it belongs to.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public string CheckSum
		{
			get
			{
				System.Text.StringBuilder sb = new System.Text.StringBuilder();
				if (this.MapFk != null) { sb.Append(this.MapFk.ToString()); }
				if (this.SectionFk != null) { sb.Append(this.SectionFk.ToString()); }
				if (this.SpecieFk != null) { sb.Append(this.SpecieFk.ToString()); }
				if (this.ClassFK != null) { sb.Append(this.ClassFK.ToString()); }
				if (this.LengthFk != null) { sb.Append(this.LengthFk.ToString()); }
				if (this.TreatmentFk != null) { sb.Append(this.TreatmentFk.ToString()); }
				if (this.Latitude != null) { sb.Append(this.Latitude.ToString()); }
				if (this.Longitude != null) { sb.Append(this.Longitude.ToString()); }
				if (this.InspBy != null) { sb.Append(this.InspBy.ToString()); }
				if (this.Number != null) { sb.Append(this.Number.ToString()); }
				if (this.AcquisitionDate != null) { sb.Append(this.AcquisitionDate.ToString()); }
				if (this.Year != null) { sb.Append(this.Year.ToString()); }
				if (this.LVisit != null) { sb.Append(this.LVisit.ToString()); }
				if (this.D804 != null) { sb.Append(this.D804.ToString()); }
				if (this.DistributionType != null) { sb.Append(this.DistributionType.ToString()); }
				if (this.UserFk != null) { sb.Append(this.UserFk.ToString()); }
				if (this.VendorFk != null) { sb.Append(this.VendorFk.ToString()); }
				if (this.InspectorFk != null) { sb.Append(this.InspectorFk.ToString()); }
				if (this.ProjectFk != null) { sb.Append(this.ProjectFk.ToString()); }
				if (this.Utility_Asset_Distributions_PoleFk != null) { sb.Append(this.Utility_Asset_Distributions_PoleFk.ToString()); }
				if (this.GuardsQuantity != null) { sb.Append(this.GuardsQuantity.ToString()); }
				if (this.PoleTag != null) { sb.Append(this.PoleTag.ToString()); }
				if (this.GroundWireRepair != null) { sb.Append(this.GroundWireRepair.ToString()); }
				if (this.Billable != null) { sb.Append(this.Billable.ToString()); }
				if (this.Kv != null) { sb.Append(this.Kv.ToString()); }
				if (this.Circuit != null) { sb.Append(this.Circuit.ToString()); }
				if (this.ConductorType != null) { sb.Append(this.ConductorType.ToString()); }
				if (this.ACSR != null) { sb.Append(this.ACSR.ToString()); }
				
				return MakeHash(sb.ToString());
			}
			private set
			{
					//Intentionally not implimented. Set is only available for serialization.
					//Due to reconstruction of the object upon deserialization in WCF this set
					//is called regardless of whether it is private. For this reason the method
					//contains no code nor a NotImplemented exception.
			}
		}
		
		/// <summary>
		/// Stores the string that represents the original checksum for <c>VendorDistributionPoleEntity</c>.
		/// </summary>
		private string prop_CheckSumOriginal = string.Empty;
		/// <summary>
		/// Gets or Sets the original checksum loaded from the database when <c>VendorDistributionPoleEntity</c> was first constructed.
		/// </summary>
		/// <remarks>Stored so that its value can be compared to the checksum in the database record when writing <c>VendorDistributionPoleEntity</c> 
		/// back to the database. When checksum verification is used, this comparison makes sure that <c>VendorDistributionPoleFactory</c> is writing to the correct, 
		/// and unmodified, record from which <c>VendorDistributionPoleEntity</c> was created.
		/// </remarks>
		/// <value>Original checksum value loaded from the database for <c>VendorDistributionPoleEntity</c>.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public string CheckSumOriginal
		{
			get
			{
				return prop_CheckSumOriginal;
			}
			set
			{
				prop_CheckSumOriginal = value;
			}
		}
		#endregion
		
	}
}

